package app.controller.msgmanage;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.mess.warningmess.Bean4WarnMessInfo;
import com.mess.warningmess.WarningMass;

import app.schedule.SpringApplicationContextHolder;
import app.service.DeviceManageService;
import app.service.FacilitiesManageService;
import app.service.UserManageService;
import refactor.entity.Device;
import siotwx.dao.EventlogDao;
import siotwx.dao.Group_facDao;
import siotwx.dao.Group_userDao;
import siotwx.entity.Eventlog;
import siotwx.entity.Facilities;
import siotwx.entity.Facmonitoring;
import siotwx.entity.Group_fac;
import siotwx.entity.Group_user;
import siotwx.entity.Module;
import siotwx.entity.User;


/**
 * 这个类用于处理接收到的区域服务器实时转发过来的消息
 * @author Haoqi
 *2017-10-19 09:01:08
 */
public class MsgManageSupport {
	
	private DeviceManageService dms = (DeviceManageService) SpringApplicationContextHolder.context.getBean("DeviceManageService");

	private FacilitiesManageService fms=(FacilitiesManageService) SpringApplicationContextHolder.context.getBean("FacilitiesManageService");
	
	private UserManageService ums=(UserManageService) SpringApplicationContextHolder.context.getBean("UserManageService");
	
	private Group_facDao group_facDao=(Group_facDao) SpringApplicationContextHolder.context.getBean("Group_facDao");
	
	private Group_userDao group_userDao=(Group_userDao) SpringApplicationContextHolder.context.getBean("Group_userDao");
	
	private EventlogDao eventlogDao=(EventlogDao) SpringApplicationContextHolder.context.getBean("EventlogDao");

	/**
	 * 对应 上行 控制类型98，硬件主动上报故障信息的处理
	 * @param msgArray
	 * @param d_time
	 * @return
	 */
	public  String faultHandle(String[] msgArray,long d_time){
		
		//设备编码
		String devCode = msgArray[0];
		//控制类型
		String controlCode = msgArray[1];
		//故障类型
		String faultType = msgArray[2];
		
		
		//判断设备是否被绑定
		Device device= dms.toDecideBind(devCode);
		if (device!=null) {
			//如果设备有效，则把故障信息录入数据库
			Facilities fac = fms.get(device.getFacilitiesId());

			
			dms.saveDevFault(device, fac, Integer.valueOf(faultType), d_time);
		
			//获取设备类型设施名称和相关人员信息
			String msg ="发生故障";
			if (faultType.equals("0")) {
				msg="恢复正常";
			}
			
			Module module = dms.getModule(device.getModId());

			User user = ums.findUser(fac.getUser_id());
			/** 
			 *  周超 修改 2018-5-30 14:49:38 添加将设备的故障信息存入数据库，并关联到相关用户进行处理
			 */
			
			String sql="SELECT * FROM eventlog WHERE device_id="+device.getId()+" AND type_id=7 AND result=0 ORDER BY startTime DESC LIMIT 0,1";
			List<Eventlog> bySql = eventlogDao.getBySql(sql);
			if (bySql==null||bySql.size()<1) {
				Eventlog log=new Eventlog(null,
						module.getId(),
						device.getId(),
						fac.getId(),
						user.getId(),
						0,
						7,
						"",
						"",
						"",
						"0",
						System.currentTimeMillis(),
						0L,
						"",
						"1");
				eventlogDao.insert(log);
			}else {
				Eventlog eventlog = bySql.get(0);
				eventlog.setResult("1");
				eventlog.setEndTime(System.currentTimeMillis());
				eventlogDao.update(eventlog);
			}
			

			/** */
			
			/**
			 *  周超 修改 2018-5-30 10:26:05 该部分修改用来更改短信的发送机制（由原来的发送设备管理员改发送设备组管理员）
			 */
			Map<String, Object> param=new HashMap<>();
			param.put(Group_fac.FieldName.fac_id.toString(), device.getFacilitiesId());
			List<Group_fac> group_facDaoList = group_facDao.getlist(param);
			if (group_facDaoList!=null&&group_facDaoList.size()>0) {
				Group_fac group_fac = group_facDaoList.get(0);
				Map<String, Object> par=new HashMap<>();
				par.put(Group_user.FieldName.group_id.toString(), group_fac.getGroup_id());
				par.put(Group_user.FieldName.is_deleted.toString(), 0);
				List<Group_user> userList = group_userDao.getlist(par);
				if (userList!=null&&userList.size()>0) {
					user = ums.findUser(userList.get(0).getUser_id());
				}
			}
			/**   */
			
			//发送短信
			Bean4WarnMessInfo info = new Bean4WarnMessInfo(devCode, module.getName(), fac.getDescription(), "", user.getRealName(), user.getPhoneNumber(), msg);
			WarningMass.sendMess(info);
		}

		//返回服务器响应
		
		String rep = "("+devCode+")";
		return rep;
	}
	
	/**
	 * 对应 上行 控制类型51  硬件响应服务器读取心跳参数
	 * @param msgArray
	 * @param d_time
	 */
	public  void heartbeatHandle(String[] msgArray,long d_time){
		//设备编码
		String devCode = msgArray[0];
		//控制类型码
		String controlCode = msgArray[1];
		
		String tempStr = msgArray[2];
		
		String tempArray[] = tempStr.split("-");
		//心跳间隔
		String span = tempArray[0];
		
		
		/*具体操作容后再做
		 * 
		 */

	}
	
	/**
	 * 对应 上行 控制类型码53  硬件响应服务器设置心跳参数
	 * @param msgArray
	 * @param d_time
	 */
	public  void  deviceRespondToChangeHeartbeat(String[] msgArray,long d_time){
		
		//设备编码
		String devCode = msgArray[0];
		//控制类型码
		String controlCode = msgArray[1];
		
		String tempStr = msgArray[2];
		
		String tempArray[] = tempStr.split("-");
		//心跳间隔
		String span = tempArray[0];
		
		/*相应入库操作，等数据库修改后来做
		 * 
		 * 
		 * 
		 */
		
		
	}
	
	/**
	 * 对应 上行 控制类型码55  硬件响应服务器读取等待用户开锁时间参数
	 * @param msgArray
	 * @param d_time
	 */
	public  void deviceRespondToServerRequestLockTime(String[] msgArray,long d_time){
		//设备编码
		String devCode = msgArray[0];
		//控制类型码
		String controlCode = msgArray[1];
		//开锁时间间隔
		String lockTime = msgArray[2];
		
		/*
		 * 具体操作先放一放
		 * 
		 * 
		 */
	}
	
	/**
	 * 对应 上行 控制类型码57 硬件响应服务器设置等待用户开锁时间参数 
	 * @param msgArray
	 * @param d_time
	 */
	public  void deviceRespondToServerSetLockTime(String[] msgArray,long d_time){
		
		//设备编码
		String devCode = msgArray[0];
		//控制类型码
		String controlCode = msgArray[1];
		//开锁时间间隔
		String lockTime = msgArray[2];
		
		/*
		 * 具体操作先放一放
		 * 
		 * 
		 */
	}
	
	/**
	 * 对应 上行 控制类型码59  硬件响应服务器读取等待用户开门时间参数
	 * @param msgArray
	 * @param d_time
	 */
	public  void deviceRespondToServerRequestDoorTime(String[] msgArray,long d_time){
		//设备编码
		String devCode = msgArray[0];
		//控制类型码
		String controlCode = msgArray[1];
		//开锁时间间隔
		String lockTime = msgArray[2];
		
		/*
		 * 具体操作先放一放
		 * 
		 * 
		 */
	}
	
	/**
	 * 对应 上行 控制类型码61 硬件响应服务器设置等待用户开门时间参数 
	 * @param msgArray
	 * @param d_time
	 */
	public  void deviceRespondToServerSetDoorTime(String[] msgArray,long d_time){
		
		//设备编码
		String devCode = msgArray[0];
		//控制类型码
		String controlCode = msgArray[1];
		//开锁时间间隔
		String lockTime = msgArray[2];
		
		/*
		 * 具体操作先放一放
		 * 
		 * 
		 */
	}
	
	/**
	 * 对应 上行 控制类型码63  硬件响应服务器设置服务器地址及端口
	 * @param msgArray
	 * @param d_time
	 */
	public void deviceRespondToChangeIp(String[] msgArray,long d_time){
		
		//设备编码
		String devCode=msgArray[0];
		//控制类型码
		String controlCode =msgArray[1];
		//IP地址
		String ipAddress = msgArray[2];
		//端口号
		String port = msgArray[3];
		
		/*具体操作容后再做
		 * 
		 * */
		
		
	}
	
	/**
	 * 对应 上行 控制类型码64  硬件向备用服务器主动报告与主服务器通信异常
	 * @param msgArray
	 * @param d_time
	 */
	public String deviceReportCommunicationsError(String[] msgArray,long d_time){
		//设备编码
		String devCode=msgArray[0];
		//控制类型码
		String controlCode =msgArray[1];
		//IP地址
		String ipAddress = msgArray[2];
		
		String[] tempArray = msgArray[3].split("_");
		//端口
		String port = tempArray[0];
		//信号强度
		String signalIntensity = tempArray[1];
		
		/*具体操作容后再做
		 * 
		 * */
		
		return "("+devCode+")";
	}
	
	/**
	 * 对应 上行 控制类型码00  硬件主动上报心跳 
	 * @param msgArray
	 * @param d_time
	 * @return
	 */
	public  String receiveHeartbeat(String[] msgArray,long d_time){
		
		//设备编码
		String devCode = msgArray[0];
		//控制类型码
		String controlCode = msgArray[1];
		String tempMsg ="";
		//信息体
		if (msgArray.length>2) {
			 tempMsg=msgArray[2];
		}
		
		
		//获取设备类型
		String devType = devCode.substring(0, 1);
		
		//如果是地井设备
		if (devType.equals("W")) {
			String[] tempArray = tempMsg.split("_");
			//井盖状态，发来的数据中1表示井盖打开，0表示井盖关闭。
			String status = tempArray[0];
			//信号强度
			String signalIntensity =  tempArray[1];
			//收到字符串的时间
			String tempTime = tempArray[2];
			

			long timeNow = formatTime(tempTime);
			
			
			/*
			 * 具体操作容后再做
			 * 
			 */
	
		}
		//如果是通断电设备
		if (devType.equals("E")) {
			
			String[] tempArray = tempMsg.split("_");
			
			//通断电状态，接收到的数据里，1表示有电，0表示没电
			String status = tempArray[0];
			//信号强度
			String signalIntensity =tempArray[1];
			//收到的字符串时间
			String tempTime = tempArray[2];
			
			//转成long型
			long timeNow = formatTime(tempTime);
			
			
			/*具体操作容后来做
			 * 
			 * 
			 * 
			 */
			
		}
		//如果是机柜锁控
		if (devType.equals("L")) {
			String[] tempArray = tempMsg.split("-");
			
			//控锁状态
			String intention = tempArray[0];
			//锁状态
			String lockStu = tempArray[1];
			//门状态
			String doorStu = tempArray[2];
			//电量
			String battery = tempArray[3];
			
			//信号强度和时间
			String[] tempArray2 = tempArray[4].split("_");
			//信号强度
			String signalIntensity = tempArray2[0];
			//收到的时间字符串
			String tempTime = tempArray2[1];
			
			//转成long型
			long timeNow = formatTime(tempTime);
			
			/*具体操作容后来做
			 * 
			 * 
			 * 
			 */
			
			
		}
		//如果是机房锁控
		if (devType.equals("D")) {
			
			String[] tempArray =tempMsg.split("_");
			
			//信号强度
			String signalIntensity = tempArray[0];
			//收到的时间字符串
			String tempTime = tempArray[1];
			
			//转成long型
			long timeNow = formatTime(tempTime);
			
			/*具体操作容后来做
			 * 
			 * 
			 * */
		}
		
		String resp = "("+devCode+")";
		
		return resp;
	
	}
	
	
	/**
	 * 对应 上行 控制类型代码04  地井硬件主动上报地井井盖状态变化信息
	 * @param msgArray
	 * @param d_time
	 * @return
	 */
//	public  String coverReportStu(String[] msgArray,long d_time){
//		//设备编码
//		String devCode = msgArray[0];
//		//控制类型码
//		String controlCode = msgArray[1];
//		//信息体
//		String tempMsg = msgArray[2];
//		
//		String[] tempArray = tempMsg.split("-");
//		//当前状态
//		String triggerStu = tempArray[0];
//		//变化次数
//		String changeTimes = tempArray[1];
//		//检测到状态变化时的状态
//		String lastStu =tempArray[2];
//		//时间和信号强度
//		String tempMsg2 = tempArray[3];
//		
//		String[] tempArray2 = tempMsg2.split("_");
//		
//		//最新状态的时间 
//		String tempTime = tempArray2[2];
//		//信号强度
//		String signalIntensity =tempArray2[1];
//		
//		//转成long型
//		long timeNow = formatTime(tempTime);
//		
//		String tempStu="";
//		if (triggerStu.equals("1")) {
//			tempStu = "0";
//		}else{
//			tempStu = "1";
//		}
//
//		DatabaseUtils databaseUtils = new DatabaseUtils();
//		//判断设备是否被绑定，以及设施的工作状态有效
//		Device device = databaseUtils.ToDecideBind(devCode);
//		if (device!=null) {
//				//将这条井盖状态变化信息录入数据库，前提是将对应的所有旧信息flag置0
//				Map<Object, Object> param = new HashMap<>();
//				param.put(Eventlog.FieldName.mod_id, device.getMod_id());
//				param.put(Eventlog.FieldName.device_id, device.getId());
//				param.put(Eventlog.FieldName.facilities_id, device.getFacilities_id());
//				param.put(Eventlog.FieldName.type_id, 2);
//				param.put(Eventlog.FieldName.flag, "1");
//				
//				List<Eventlog> eventlogs = null;
//				
//				try {
//					eventlogs = eventlogService.getList(param);
//				} catch (Exception e) {
//					System.out.println("获取井盖历史记录出错！");
//				}
//				
//				if (eventlogs!=null&&!eventlogs.isEmpty()) {
//					for(int index=0;index<eventlogs.size();index++){
//						Eventlog eventlog = eventlogs.get(index);
//						eventlog.setFlag("0");
//						eventlogService.update(eventlog);
//					}
//				}
//				
//				//添加记录
//				Eventlog eventlog = new Eventlog(null, device.getMod_id(), device.getId(), device.getFacilities_id(), 0, 0, 2, tempStu, "", "", "", timeNow, 0L, "", "1");
//				eventlogService.save(eventlog);
//
//				//获取设备类型设施名称和相关人员信息
//				String oc="";
//				if (triggerStu.equals("1")) {
//					oc="打开";
//				}else{
//					oc="关闭";
//				}
//				
//				Module module = moduleService.get(device.getMod_id());
//				Facilities facilities = fService.get(device.getFacilities_id());
//				User user = userService.get(facilities.getUser_id());
//				//发送短信
//				Bean4WarnMessInfo info = new Bean4WarnMessInfo(devCode, module.getName(), facilities.getDescription(), "", user.getRealName(), user.getPhoneNumber(), oc);
//				WarningMass.sendMess(info);
//		
//		}
//		
//		String resp = "("+devCode+")";
//		
//		return resp;
//		
//	}
	
	/**
	 * 对应 上行 控制类型码06 通断电设备主动上报通断电状态信息，地井设备主动上报井盖状态变化信息
	 * @param msgArray
	 * @param d_time
	 * @return
	 */
	public  String onoffDeviceReportStu(String[] msgArray,long d_time){
		//通断电和地井设备编码
		String devCode = msgArray[0];
		
		//根据设备类型进入不同处理
		if(devCode.substring(0,1).equals("E")){
			//控制类型码
			String controlCode =msgArray[1];
			//信息体
			String status = msgArray[2];

			String[] tempArray = status.split("-");
			//当前是否有电
			String stu1= tempArray[0];
			//检测到变化了几次
			String times = tempArray[1];
			//检测到状态变化时的状态
			String stu2 = tempArray[2];
			
			String[] tempArray2 = tempArray[3].split("_");
			//检测状态变化到的时间
			String time1 = tempArray2[0];
			//信号强度
			String strength = tempArray2[1];
			//发送时的时间
			String time2 = tempArray2[2];
			
			

			
			long timeNow = formatTime(time2);
			
			
			
			//判断设备是否被绑定，并且对应设施的工作状态是否有效
			Device device = dms.toDecideBind(devCode);
			if (device!=null) {

				//将这条数据录入数据库，前提是将其对应的相关记录flag置0
				
				List<Eventlog> eventlogs=null;
				
				try {
					
					eventlogs = dms.getDevLatestStu(device);
				} catch (Exception e) {
					System.out.println("从eventlog中获取设备对应记录失败！");
				}
				
				if (eventlogs!=null&&!eventlogs.isEmpty()) {
					for(int index= 0;index<eventlogs.size();index++){
						Eventlog eventlog = eventlogs.get(index);
						
						dms.upadateLatestDevStu(eventlog, "0");
					}
					
				}
				
				//添加记录
				dms.saveDevStu(device, 0, stu1, "","", timeNow, "1");
				//获取设备类型设施名称和相关人员信息
				String oc="";
				if (stu1.equals("0")) {
					oc="断电";
				}else{
					oc="通电";
				}
				
				Module module = dms.getModule(device.getModId());
				Facilities facilities = fms.get(device.getFacilitiesId());
				User user = ums.findUser(facilities.getUser_id());
				
				/** 
				 *  周超 修改 2018-5-30 14:49:38 添加将设备的故障信息存入数据库，并关联到相关用户进行处理
				 */
				String sql="SELECT * FROM eventlog WHERE device_id="+device.getId()+" AND type_id=7 ORDER BY startTime DESC LIMIT 0,1";
				List<Eventlog> bySql = eventlogDao.getBySql(sql);
				if (bySql==null||bySql.size()<1) {
					Eventlog log=new Eventlog(null,
							module.getId(),
							device.getId(),
							facilities.getId(),
							user.getId(),
							0,
							7,
							"",
							"",
							"",
							"0",
							System.currentTimeMillis(),
							0L,
							"",
							"1");
					eventlogDao.insert(log);
				}else {
					Eventlog eventlog = bySql.get(0);
					eventlog.setResult("1");
					eventlogDao.update(eventlog);
				}
				
				/** */
				
				/**
				 *  周超 修改 2018-5-30 10:26:05 该部分修改用来更改短信的发送机制（由原来的发送设备管理员改发送设备组管理员）
				 */
				Map<String, Object> param=new HashMap<>();
				param.put(Group_fac.FieldName.fac_id.toString(), device.getFacilitiesId());
				List<Group_fac> group_facDaoList = group_facDao.getlist(param);
				if (group_facDaoList!=null&&group_facDaoList.size()>0) {
					Group_fac group_fac = group_facDaoList.get(0);
					Map<String, Object> par=new HashMap<>();
					par.put(Group_user.FieldName.group_id.toString(), group_fac.getGroup_id());
					par.put(Group_user.FieldName.is_deleted.toString(), 0);
					List<Group_user> userList = group_userDao.getlist(par);
					if (userList!=null&&userList.size()>0) {
						user = ums.findUser(userList.get(0).getUser_id());
					}
				}
				/**   */
				
				//发送短信
				Bean4WarnMessInfo info = new Bean4WarnMessInfo(devCode, module.getName(), facilities.getDescription(), "", user.getRealName(), user.getPhoneNumber(), oc);
				WarningMass.sendMess(info);
			
			}
			
		}else if(devCode.substring(0,1).equals("W")){
			//如果是地井设备
			
			//控制类型码
			String controlCode = msgArray[1];
			//信息体
			String tempMsg = msgArray[2];
			
			String[] tempArray = tempMsg.split("-");
			//当前状态
			String triggerStu = tempArray[0];
			//变化次数
			String changeTimes = tempArray[1];
			//检测到状态变化时的状态
			String lastStu =tempArray[2];
			//时间和信号强度
			String tempMsg2 = tempArray[3];
			
			String[] tempArray2 = tempMsg2.split("_");
			
			//最新状态的时间 
			String tempTime = tempArray2[2];
			//信号强度
			String signalIntensity =tempArray2[1];
			
			//转成long型
			long timeNow = formatTime(tempTime);
			
			String tempStu="";
			if (triggerStu.equals("1")) {
				tempStu = "0";
			}else{
				tempStu = "1";
			}

			//判断设备是否被绑定，以及设施的工作状态有效
			Device device = dms.toDecideBind(devCode);
			if (device!=null) {
					//将这条井盖状态变化信息录入数据库，前提是将对应的所有旧信息flag置0
					
					List<Eventlog> eventlogs = null;
					
					try {
						eventlogs = dms.getDevLatestStu(device);
					} catch (Exception e) {
						System.out.println("获取井盖历史记录出错！");
					}
					
					if (eventlogs!=null&&!eventlogs.isEmpty()) {
						for(int index=0;index<eventlogs.size();index++){
							Eventlog eventlog = eventlogs.get(index);
							dms.upadateLatestDevStu(eventlog, "0");
						}
					}
					
					//添加记录
					dms.saveDevStu(device, 0, tempStu, "","", timeNow, "1");
					//获取设备类型设施名称和相关人员信息
					String oc="";
					if (triggerStu.equals("1")) {
						oc="打开";
					}else{
						oc="关闭";
					}
					
					
					
					Module module = dms.getModule(device.getModId());
					Facilities facilities = fms.get(device.getFacilitiesId());
					User user = ums.findUser(facilities.getUser_id());
					/** 
					 *  周超 修改 2018-5-30 14:49:38 添加将设备的故障信息存入数据库，并关联到相关用户进行处理
					 */
					String sql="SELECT * FROM eventlog WHERE device_id="+device.getId()+" AND type_id=7 ORDER BY startTime DESC LIMIT 0,1";
					List<Eventlog> bySql = eventlogDao.getBySql(sql);
					if (bySql==null||bySql.size()<1) {
						Eventlog log=new Eventlog(null,
								module.getId(),
								device.getId(),
								facilities.getId(),
								user.getId(),
								0,
								7,
								"",
								"",
								"",
								"0",
								System.currentTimeMillis(),
								0L,
								"",
								"1");
						eventlogDao.insert(log);
					}else {
						Eventlog eventlog = bySql.get(0);
						eventlog.setResult("1");
						eventlogDao.update(eventlog);
					}
					
					/** */

					/**
					 *  周超 修改 2018-5-30 10:26:05 该部分修改用来更改短信的发送机制（由原来的发送设备管理员改发送设备组管理员）
					 */
					Map<String, Object> param=new HashMap<>();
					param.put(Group_fac.FieldName.fac_id.toString(), device.getFacilitiesId());
					List<Group_fac> group_facDaoList = group_facDao.getlist(param);
					if (group_facDaoList!=null&&group_facDaoList.size()>0) {
						Group_fac group_fac = group_facDaoList.get(0);
						Map<String, Object> par=new HashMap<>();
						par.put(Group_user.FieldName.group_id.toString(), group_fac.getGroup_id());
						par.put(Group_user.FieldName.is_deleted.toString(), 0);
						List<Group_user> userList = group_userDao.getlist(par);
						if (userList!=null&&userList.size()>0) {
							user = ums.findUser(userList.get(0).getUser_id());
						}
					}
					/**   */
					
					//发送短信
					Bean4WarnMessInfo info = new Bean4WarnMessInfo(devCode, module.getName(), facilities.getDescription(), "", user.getRealName(), user.getPhoneNumber(), oc);
					WarningMass.sendMess(info);
			
			}
			
		}
		
		String resp= "("+devCode+")";
		
		return resp;

	}
	
	
	/**
	 * 对应上行 控制类型码 09 硬件响应完成机房开门
	 * @param msgArray
	 * @param d_time
	 */
	public  void deviceRespondToFinishOpenDoor(String[] msgArray,long d_time){
		//通断电设备编码
		String devCode = msgArray[0];
		//控制类型码
		String controlCode =msgArray[1];
		
		//状态信号强度和时间
		String[] tempArray = msgArray[2].split("_");
		//门状态
		String status = tempArray[0];
		//信号强度
		String signalIntensity = tempArray[1];
		//时间字符串
		String tempTime=tempArray[2];
		
		//转成long型
		long timeNow = formatTime(tempTime);
		
		
		String tempStu ="";
		if (status.equals("O")) {
			tempStu="0";
		}else{
			tempStu = "1";
		}
		
		//根据设备code查询设备是否绑定，如果绑定查询设施工作状态是否有效
		Device device = dms.toDecideBind(devCode);
		if (device!=null) {
			
				//从内存中的Stack4LockOpener获取设备code对应的记录，确定此条开锁请求是有谁发起的
				int userID = Stack4LockOpener.getUserID(device.getCode());
				if (userID<0) {
					userID =0;
				}
				//将数据库中对应相关信息flag设为0，并且将此条信息录入数据库
				//添加记录
				dms.saveDevStu(device, userID, "", tempStu,"",timeNow, "0");
				
				//获取设备类型设施名称和相关人员信息
				String oc="";
				if (status.equals("O")) {
					oc="打开";
				}else{
					oc="关闭";
				}
				
				Module module = dms.getModule(device.getModId());
				Facilities facilities = fms.get(device.getFacilitiesId());
				User user = ums.findUser(facilities.getUser_id());
				

				/**
				 *  周超 修改 2018-5-30 10:26:05 该部分修改用来更改短信的发送机制（由原来的发送设备管理员改发送设备组管理员）
				 */
				Map<String, Object> param=new HashMap<>();
				param.put(Group_fac.FieldName.fac_id.toString(), device.getFacilitiesId());
				List<Group_fac> group_facDaoList = group_facDao.getlist(param);
				if (group_facDaoList!=null&&group_facDaoList.size()>0) {
					Group_fac group_fac = group_facDaoList.get(0);
					Map<String, Object> par=new HashMap<>();
					par.put(Group_user.FieldName.group_id.toString(), group_fac.getGroup_id());
					par.put(Group_user.FieldName.is_deleted.toString(), 0);
					List<Group_user> userList = group_userDao.getlist(par);
					if (userList!=null&&userList.size()>0) {
						user = ums.findUser(userList.get(0).getUser_id());
					}
				}

				//发送短信
				Bean4WarnMessInfo info = new Bean4WarnMessInfo(devCode, module.getName(), facilities.getDescription(), "", Stack4LockOpener.getUserName(devCode), user.getPhoneNumber(), oc);
				//记得删除Stack4LockOpener中的devCode
				Stack4LockOpener.remove(devCode);
				
				WarningMass.sendMess(info);
				
		}
	
	}
	
	/**
	 * 对应 上行 控制类型码10 机柜锁硬件主动上报电量信息
	 * @param msgArray
	 * @param d_time
	 * @return
	 */
	public  String lockReportElectricQuantity(String[] msgArray,long d_time){
		//设备编码
		String devCode = msgArray[0];
		//控制类型码
		String controlCode = msgArray[1];
		//信息体
		String tempMsg = msgArray[2];
		
		String[] tempArray = tempMsg.split("-");
		//控锁状态
		String intention = tempArray[0];
		//锁状态
		String lockStu = tempArray[1];
		
		
		
		String templockStu ="";
		if (lockStu.equals("O")) {
			templockStu="0";
		}else{
			templockStu="1";
		}
		//门状态
		String doorStu = tempArray[2];
		String tempdoorStu ="";
		if (doorStu.equals("O")) {
			tempdoorStu="0";
		}else{
			tempdoorStu="1";
		}
		
		//剩余电量
		String battery = tempArray[3];
		
		//信号强度和时间
		String tempMsg2 = tempArray[4];
		
		String[] tempArray2 = tempMsg2.split("_");
		//信号强度
		String signalIntensity=tempArray2[0];
		//收到的时间字符串
		String tempTime=tempArray2[1];
		

		//转成long型
		long timeNow = formatTime(tempTime);
		
		
		//从Facmonitoring中查找对应devCode的记录
		Map<Object, Object> param = new HashMap<>();
		param.put(Facmonitoring.FieldName.devCode,devCode);
		
		Facmonitoring facmonitoring = fms.getFacmonitoring(devCode);
		
		if (facmonitoring!=null) {
			
			//获取对应的eventlogId,修改此eventlog记录的信息
			int eventlogId = facmonitoring.getEventId();
			
			Eventlog eventlog = fms.getEvent(eventlogId);
			
			
			fms.updateDevstuDoorstuElectricity(eventlog, templockStu, tempdoorStu, battery);
		}
		
		String resp = "("+devCode+")";
		
		return resp;
		
	}
	
	/**
	 * 对应 上行  控制类型码12 硬件主动上报机柜锁按键触发开门请求
	 * @param msgArray
	 * @param d_time
	 * @return
	 */
	public  String lockDeviceRequestOpenDoor(String[] msgArray,long d_time){
		//设备编码
		String devCode = msgArray[0];
		//控制类型码
		String controlCode = msgArray[1];
		
		
		//判断设备是否被绑定
		Device device = dms.toDecideBind(devCode);
		String resp = "("+devCode+",13,"+"C"+")";
		if (device!=null) {
			//查询是否有这个设备对应的符合开门的标准
			DeviceCache deviceCache = DeviceCache.getInstance();

			if (deviceCache.canBeOpen(devCode)) {
				resp="("+devCode+",13,"+"O"+")";
			}
			
			//删除单例中此设备的允许开门缓存
			deviceCache.del(devCode);
		}

		return resp;
	}
	
	/**
	 * 对应上行 控制类型码14 硬件主动上报机柜锁和门状态发生变化
	 * @param msgArray
	 * @param d_time
	 * @return
	 */
	public  String lockDeviceReportLockAndDoorStu(String[] msgArray,long d_time){
		//设备编码
		String devCode=msgArray[0];
		//控制类型码
		String controlCode = msgArray[1];
		//信息体
		String tempMsg = msgArray[2];
		
		String[] tempArray = tempMsg.split("_");
		
		//锁信息
		String lockMsg = tempArray[0];
		String[] templockMsg = lockMsg.split("-");
		String lockStu = templockMsg[0];
		String templockStu ="";
		if (lockStu.equals("O")) {
			templockStu = "0";
		}else{
			templockStu="1";
		}
		
		//门信息、电量和信号强度
		String doorMsg = tempArray[1];
		String[] tempdoorMsg = doorMsg.split("-");
		String doorStu = tempdoorMsg[0];
		String tempdoorStu = "";
		if (doorStu.equals("O")) {
			tempdoorStu="0";
		}else{
			tempdoorStu="1";
		}
		
		//电量信息
		String battery = tempdoorMsg[3];
		//信号强度
		String signalIntensity = tempdoorMsg[4];
		
		
		//时间字符串
		String tempTime = tempArray[2];
		

		//转成long型
		long timeNow = formatTime(tempTime);
		
		
		
		//查询设备是否被绑定,如果被绑定则判断设备设施的工作状态是否正常

		Device device = dms.toDecideBind(devCode);
		
		if (device!=null) {
				//将数据库中对应相关信息flag设为0，并且将此条信息录入数据库
				
				List<Eventlog> eventlogs = null;
				
				try {
					eventlogs=dms.getDevLatestStu(device);
				} catch (Exception e) {
					System.out.println("获取机柜锁相关信息失败！");
				}
				
				if (eventlogs!=null&&!eventlogs.isEmpty()) {
					for(int index=0;index<eventlogs.size();index++){
						
						dms.upadateLatestDevStu(eventlogs.get(index), "0");
					}
				}
				
				
				//从内存中的Stack4LockOpener获取设备code对应的记录，确定此条开锁请求是由谁发起的
				int userID = Stack4LockOpener.getUserID(device.getCode());
				if (userID<0) {
					userID =0;
				}
				
				//添加记录
				dms.saveDevStu(device, userID, templockStu, tempdoorStu,battery, timeNow, "1");
				
				
				
				//获取设备类型设施名称和相关人员信息
				String oc1="";
				if (lockStu.equals("O")) {
					oc1="锁打开";
				}else{
					oc1="锁关闭";
				}
				
				String oc2="";
				if (doorStu.equals("O")) {
					oc2="门打开";
				}else{
					oc2="门关闭";
				}
				
				String oclast=oc1+","+oc2;
				
				Module module = dms.getModule(device.getModId());
				Facilities facilities = fms.get(device.getFacilitiesId());
				User user = ums.findUser(facilities.getUser_id());

				/**
				 *  周超 修改 2018-5-30 10:26:05 该部分修改用来更改短信的发送机制（由原来的发送设备管理员改发送设备组管理员）
				 */
				Map<String, Object> param=new HashMap<>();
				param.put(Group_fac.FieldName.fac_id.toString(), device.getFacilitiesId());
				List<Group_fac> group_facDaoList = group_facDao.getlist(param);
				if (group_facDaoList!=null&&group_facDaoList.size()>0) {
					Group_fac group_fac = group_facDaoList.get(0);
					Map<String, Object> par=new HashMap<>();
					par.put(Group_user.FieldName.group_id.toString(), group_fac.getGroup_id());
					par.put(Group_user.FieldName.is_deleted.toString(), 0);
					List<Group_user> userList = group_userDao.getlist(par);
					if (userList!=null&&userList.size()>0) {
						user = ums.findUser(userList.get(0).getUser_id());
					}
				}
				/**   */
				
				//发送短信
				Bean4WarnMessInfo info = new Bean4WarnMessInfo(devCode, module.getName(), facilities.getDescription(), "", Stack4LockOpener.getUserName(devCode), user.getPhoneNumber(), oclast);
				//记得删除Stack4LockOpener中的devCode
				Stack4LockOpener.remove(devCode);
				WarningMass.sendMess(info);
		
		}
		
		String resp = "("+devCode+")";
		return resp;
	}
	
	
	/**
	 * 对应上行 控制类型码16 用户未执行开门，硬件主动上报
	 * @param msgArray
	 * @param d_time
	 * @return
	 */
	public  String deviceReportUserNotOpenDoor(String[] msgArray,long d_time){
		//设备编码
		String devCode = msgArray[0];
		//设备控制类型码
		String controlCode = msgArray[1];
		
		//说明用户扫了码但是没有按按钮，因此将从存放开门状态的单例缓存中删除此条开门请求对应信息
		DeviceCache deviceCache = DeviceCache.getInstance();
		
			deviceCache.del(devCode);

		
		String resp = "("+devCode+")";
		return resp;
	}
	
	
	/**
	 * 格式化时间，转成long型
	 * @param tempTime
	 * @return
	 */
	private long formatTime(String tempTime){
		
		SimpleDateFormat sdf = new SimpleDateFormat("yyMMddHHmmss");
		Date date=null;
		try {
			date = sdf.parse(tempTime);
		} catch (ParseException e1) {
			System.out.println("时间转化失败！");
		}
		//转成long型
		long timeNow = date.getTime();
		
		
		return timeNow;
	}
	
	
}
